home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / SoundAndMusic / cmix / Minc / y.tab.c < prev    next >
C/C++ Source or Header  |  1992-01-27  |  14KB  |  553 lines
  1.  
  2. # line 5 "p.y"
  3. #include "defs.h"
  4. #include "lex.yy.c"
  5. #include "ext.h"
  6. #define YYDEBUG
  7. #define MAXIDLIST 200
  8.  
  9. int   i1,i2,i3,i4,i5,i6,i7,i8,i9;
  10. double atof(),f1,f2,f3,f4,f5,f6,f7,f8,f9,d1;
  11. char  *c1,*c2,*c3;
  12. Tree    tp1,tp2,tp3,tp4,tp5,tp6,tp7,tp8,tp9;
  13. SYMBOL    *sp1,*sp2,*sp3,*sp4,*sp5,*sp6,*sp7,*sp8,*sp9;
  14. int     idcount =0;    
  15. char    *idlist[MAXIDLIST];  
  16. int     interactive;
  17. char    str[200];
  18. char    strp;
  19. int     flerror;      /* set if there was an error during parsing */
  20. int    level=0;        /* keeps track whether we are in a structure*/
  21. # define LOWPRIO 257
  22. # define T_OR 258
  23. # define T_AND 259
  24. # define T_EQU 260
  25. # define UNEQU 261
  26. # define LESSEQU 262
  27. # define GTREQU 263
  28. # define T_POW 264
  29. # define CASTTOKEN 265
  30. # define FLT 266
  31. # define CTOO 267
  32. # define CTOL 268
  33. # define OTOL 269
  34. # define OTOC 270
  35. # define LTOO 271
  36. # define LTOC 272
  37. # define ID 273
  38. # define NUM 274
  39. # define T_NOT 275
  40. # define IF 276
  41. # define ELSE 277
  42. # define FOR 278
  43. # define WHILE 279
  44. # define T_TRUE 280
  45. # define T_FALSE 281
  46. # define STRING 282
  47. #define yyclearin yychar = -1
  48. #define yyerrok yyerrflag = 0
  49. extern int yychar;
  50. extern short yyerrflag;
  51. #ifndef YYMAXDEPTH
  52. #define YYMAXDEPTH 150
  53. #endif
  54. YYSTYPE yylval, yyval;
  55. # define YYERRCODE 256
  56.  
  57. # line 186 "p.y"
  58.  
  59.  
  60. declare(type)
  61. int   type;
  62. {
  63.  
  64. int  i1;
  65. SYMBOL  *sp1;
  66.  
  67.   for (i1=0;i1<idcount;i1++) {
  68.  
  69.     sp1 = lookup (idlist[i1]);
  70.     if (sp1 != NULL) {
  71.         sprintf(str,"warning: variable redefined: %s",idlist[i1]);
  72. /*  note this handling may be illegal in arbitrary scoping */
  73.         sp1->type = type;
  74.         yyerror(str);
  75.     }
  76.     else install(idlist[i1],S_GLOBAL,type);
  77.   }
  78. }    
  79.  
  80. Tree go (t1)
  81. Tree t1;
  82. {
  83.     if (interactive && level==0)   exct(t1);
  84.     if (interactive && level==0)   free_tree(t1);
  85.     return (t1);
  86. }
  87. short yyexca[] ={
  88. -1, 1,
  89.     0, -1,
  90.     -2, 0,
  91.     };
  92. # define YYNPROD 54
  93. # define YYLAST 253
  94. short yyact[]={
  95.  
  96.    9,  38,  27,  72,  38,  67,  40,  12,   9,  40,
  97.   44,  60,  92,  86,  38,  54,   9,  61,  63,  40,
  98.   64,  61,  62,  52,  54,  48,  62,  87,  30,  14,
  99.   61,  63,  29,  64,  31,  62,  41,  11,  94,  11,
  100.   70,  16,  43,  71,  15,   1,  11,  17,  55,   2,
  101.   56,  37,   5,  28,   5,  18,  19,  11,  46,  20,
  102.    0,   5,   0,   0,  32,   0,  25,   3,  50,  11,
  103.   13,   0,   5,   0,   0,   0,   0,   0,   0,  11,
  104.   11,   0,   0,  42,   5,   0,   0,   0,  13,   0,
  105.    0,   0,   0,   0,   5,   5,   0,  89,   0,  65,
  106.   51,   0,   0,  66,   0,   0,   0,   0,   0,  11,
  107.   68,  69,   0,   0,   0,   0,   0,  73,  74,  75,
  108.    0,   0,   0,   0,   5,   0,   0,   0,   0,  11,
  109.    0,  11,   0,  10,   0,  53,  52,  54,  33,   0,
  110.   90,  10,   0,   4,   5,   0,   5,   0,   0,  10,
  111.   12,   4,  91,   6,   0,   8,   7,   0,  12,   4,
  112.   93,   6,  95,   8,   7,   0,  12,  45,  47,   6,
  113.    0,   8,   7,   0,   0,   0,   0,   0,   0,   0,
  114.    0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
  115.    0,   0,   0,   0,  76,  77,  78,  79,  80,  81,
  116.   82,  83,  84,  85,   0,   0,   0,   0,   0,  21,
  117.   88,  53,  52,  54,   0,   0,   0,   0,   0,  22,
  118.   26,  24,  23,   0,   0,   0,   0,   0,   0,   0,
  119.   53,  52,  54,   0,  12,  39,  34,  12,  39,  60,
  120.    0,  35,  36,  60,   0,   0,  49,  12,  39,  57,
  121.   58,  59,  60 };
  122. short yypact[]={
  123.  
  124. -107,-1000,-107, -30,-266,-1000,-1000,-1000,-1000,-107,
  125.  -57,  -8,-1000, -31,-1000, -10,-1000, -39, -39,   2,
  126. -115,-1000,-1000,-1000,-1000,-1000,-1000,-1000, -26, -36,
  127. -1000,-266,-123, -12, -39,-1000,-1000,-1000, -39,-1000,
  128. -269,  -8,-123,-107,-1000, -25,  -1, -25,-1000,-1000,
  129. -1000,-274, -39, -39, -39, -26, -26, -26, -26, -26,
  130.  -26, -26, -26, -26, -26,-1000, -28,-1000,-1000, -32,
  131. -1000, -36,-107,-245,-236,-1000, -25, -25, -25, -25,
  132.  -25,-1000,-253,-253, -21, -21,-1000, -39, -25,-1000,
  133. -1000, -47,-107,  -3,-107,-1000 };
  134. short yypgo[]={
  135.  
  136.    0,  49,  67,  51,  64,  58, 138,  25,  36,  45,
  137.   44,  47 };
  138. short yyr1[]={
  139.  
  140.    0,   9,   1,   1,   1,   1,   2,   2,   2,   2,
  141.    2,   2,   2,   2,   2,   2,   2,   2,   2,   2,
  142.   11,   3,   3,  10,  10,   8,   5,   5,   5,   5,
  143.    5,   7,   4,   4,   4,   4,   4,   4,   4,   4,
  144.    4,   4,   4,   4,   6,   6,   6,   6,   6,   6,
  145.    6,   6,   6,   6 };
  146. short yyr2[]={
  147.  
  148.    0,   1,   1,   2,   2,   3,   2,   1,   4,   6,
  149.    4,  10,   3,   2,   2,   2,   2,   2,   2,   2,
  150.    0,   3,   4,   1,   3,   1,   1,   3,   1,   3,
  151.    0,   1,   1,   2,   3,   3,   3,   3,   3,   3,
  152.    3,   3,   1,   1,   3,   1,   3,   3,   3,   3,
  153.    3,   1,   2,   1 };
  154. short yychk[]={
  155.  
  156. -1000,  -9,  -1,  -2, 266,  -3, 276, 279, 278, 123,
  157.  256,  -8, 273,  -2,  59, -10,  -8, -11, -11, -11,
  158.   -1, 266, 276, 279, 278, 123, 277,  59,  61,  40,
  159.   59,  44,  -4,  -6, 275, 280, 281,  -3,  40, 274,
  160.   45,  -8,  -4,  40, 125,  -6,  -5,  -6,  -7, 282,
  161.   -8,  -2, 259, 258, 260,  60,  62, 261, 262, 263,
  162.  264,  42,  47,  43,  45,  -4,  -4, 274,  -2,  -2,
  163.   41,  44, 277,  -4,  -4,  -4,  -6,  -6,  -6,  -6,
  164.   -6,  -6,  -6,  -6,  -6,  -6,  41,  59,  -6,  -7,
  165.   -2,  -4,  59,  -2,  41,  -2 };
  166. short yydef[]={
  167.  
  168.    0,  -2,   1,   2,   0,   7,  20,  20,  20,   0,
  169.    0,   0,  25,   3,   4,   6,  23,   0,   0,   0,
  170.    0,  13,  14,  15,  16,  17,  18,  19,   0,  30,
  171.    5,   0,   0,  32,   0,  42,  43,  45,   0,  51,
  172.    0,  53,   0,   0,  12,  21,   0,  26,  28,  31,
  173.   24,   8,   0,   0,   0,   0,   0,   0,   0,   0,
  174.    0,   0,   0,   0,   0,  33,   0,  52,  10,   0,
  175.   22,   0,   0,  34,  35,  36,  37,  38,  39,  40,
  176.   41,  44,  46,  47,  48,  49,  50,   0,  27,  29,
  177.    9,   0,   0,   0,   0,  11 };
  178. # line 1 "/usr/lib/yaccpar"
  179. #ifndef lint
  180. static char yaccpar_sccsid[] = "@(#)yaccpar    4.1    (Berkeley)    2/11/83";
  181. #endif not lint
  182.  
  183. # define YYFLAG -1000
  184. # define YYERROR goto yyerrlab
  185. # define YYACCEPT return(0)
  186. # define YYABORT return(1)
  187.  
  188. /*    parser for yacc output    */
  189.  
  190. #ifdef YYDEBUG
  191. int yydebug = 0; /* 1 for debugging */
  192. #endif
  193. YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
  194. int yychar = -1; /* current input token number */
  195. int yynerrs = 0;  /* number of errors */
  196. short yyerrflag = 0;  /* error recovery flag */
  197.  
  198. yyparse() {
  199.  
  200.     short yys[YYMAXDEPTH];
  201.     short yyj, yym;
  202.     register YYSTYPE *yypvt;
  203.     register short yystate, *yyps, yyn;
  204.     register YYSTYPE *yypv;
  205.     register short *yyxi;
  206.  
  207.     yystate = 0;
  208.     yychar = -1;
  209.     yynerrs = 0;
  210.     yyerrflag = 0;
  211.     yyps= &yys[-1];
  212.     yypv= &yyv[-1];
  213.  
  214.  yystack:    /* put a state and value onto the stack */
  215.  
  216. #ifdef YYDEBUG
  217.     if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
  218. #endif
  219.         if( ++yyps>= &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
  220.         *yyps = yystate;
  221.         ++yypv;
  222.         *yypv = yyval;
  223.  
  224.  yynewstate:
  225.  
  226.     yyn = yypact[yystate];
  227.  
  228.     if( yyn<= YYFLAG ) goto yydefault; /* simple state */
  229.  
  230.     if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
  231.     if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;
  232.  
  233.     if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
  234.         yychar = -1;
  235.         yyval = yylval;
  236.         yystate = yyn;
  237.         if( yyerrflag > 0 ) --yyerrflag;
  238.         goto yystack;
  239.         }
  240.  
  241.  yydefault:
  242.     /* default state action */
  243.  
  244.     if( (yyn=yydef[yystate]) == -2 ) {
  245.         if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
  246.         /* look through exception table */
  247.  
  248.         for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */
  249.  
  250.         while( *(yyxi+=2) >= 0 ){
  251.             if( *yyxi == yychar ) break;
  252.             }
  253.         if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
  254.         }
  255.  
  256.     if( yyn == 0 ){ /* error */
  257.         /* error ... attempt to resume parsing */
  258.  
  259.         switch( yyerrflag ){
  260.  
  261.         case 0:   /* brand new error */
  262.  
  263.             yyerror( "syntax error" );
  264.         yyerrlab:
  265.             ++yynerrs;
  266.  
  267.         case 1:
  268.         case 2: /* incompletely recovered error ... try again */
  269.  
  270.             yyerrflag = 3;
  271.  
  272.             /* find a state where "error" is a legal shift action */
  273.  
  274.             while ( yyps >= yys ) {
  275.                yyn = yypact[*yyps] + YYERRCODE;
  276.                if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
  277.                   yystate = yyact[yyn];  /* simulate a shift of "error" */
  278.                   goto yystack;
  279.                   }
  280.                yyn = yypact[*yyps];
  281.  
  282.                /* the current yyps has no shift onn "error", pop stack */
  283.  
  284. #ifdef YYDEBUG
  285.                if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
  286. #endif
  287.                --yyps;
  288.                --yypv;
  289.                }
  290.  
  291.             /* there is no state on the stack with an error shift ... abort */
  292.  
  293.     yyabort:
  294.             return(1);
  295.  
  296.  
  297.         case 3:  /* no shift yet; clobber input char */
  298.  
  299. #ifdef YYDEBUG
  300.             if( yydebug ) printf( "error recovery discards char %d\n", yychar );
  301. #endif
  302.  
  303.             if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
  304.             yychar = -1;
  305.             goto yynewstate;   /* try again in the same state */
  306.  
  307.             }
  308.  
  309.         }
  310.  
  311.     /* reduction by production yyn */
  312.  
  313. #ifdef YYDEBUG
  314.         if( yydebug ) printf("reduce %d\n",yyn);
  315. #endif
  316.         yyps -= yyr2[yyn];
  317.         yypvt = yypv;
  318.         yypv -= yyr2[yyn];
  319.         yyval = yypv[1];
  320.         yym=yyn;
  321.             /* consult goto table to find next state */
  322.         yyn = yyr1[yyn];
  323.         yyj = yypgo[yyn] + *yyps + 1;
  324.         if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
  325.         switch(yym){
  326.             
  327. case 1:
  328. # line 42 "p.y"
  329. {program = yypvt[-0].trees;return (0);} break;
  330. case 2:
  331. # line 45 "p.y"
  332. {yyval.trees = yypvt[-0].trees;} break;
  333. case 3:
  334. # line 46 "p.y"
  335. {yyval.trees = tseq(yypvt[-1].trees,yypvt[-0].trees);} break;
  336. case 4:
  337. # line 47 "p.y"
  338. {yyval.trees = yypvt[-1].trees;} break;
  339. case 5:
  340. # line 48 "p.y"
  341. {yyval.trees = tseq(yypvt[-2].trees,yypvt[-1].trees);} break;
  342. case 6:
  343. # line 51 "p.y"
  344. { declare(T_FLOAT);idcount=0;} break;
  345. case 7:
  346. # line 52 "p.y"
  347. {
  348.                 if (level==0) 
  349.                     yyval.trees = go(yypvt[-0].trees); 
  350.                 else    yyval.trees = yypvt[-0].trees;
  351.                 } break;
  352. case 8:
  353. # line 57 "p.y"
  354. {
  355.                     level--;
  356.                     yyval.trees = go(tif(yypvt[-1].trees,yypvt[-0].trees));
  357.                     } break;
  358. case 9:
  359. # line 61 "p.y"
  360. {
  361.                     level--;
  362.                     yyval.trees = go(tifelse(yypvt[-3].trees,yypvt[-2].trees,yypvt[-0].trees));
  363.                     } break;
  364. case 10:
  365. # line 65 "p.y"
  366. {
  367.                     level--;
  368.                     yyval.trees = go(twhile(yypvt[-1].trees,yypvt[-0].trees));
  369.                     } break;
  370. case 11:
  371. # line 69 "p.y"
  372. {
  373.                     level--;
  374.                     yyval.trees = go(tfor(yypvt[-6].trees,yypvt[-4].trees,yypvt[-2].trees,yypvt[-0].trees));
  375.                     } break;
  376. case 12:
  377. # line 73 "p.y"
  378. {yyval.trees = yypvt[-1].trees;} break;
  379. case 13:
  380. # line 74 "p.y"
  381. {flerror = 1;yyval.trees=tnoop();} break;
  382. case 14:
  383. # line 75 "p.y"
  384. {flerror = 1;yyval.trees=tnoop();} break;
  385. case 15:
  386. # line 76 "p.y"
  387. {flerror = 1;yyval.trees=tnoop();} break;
  388. case 16:
  389. # line 77 "p.y"
  390. {flerror = 1;yyval.trees=tnoop();} break;
  391. case 17:
  392. # line 78 "p.y"
  393. {flerror = 1;yyval.trees=tnoop();} break;
  394. case 18:
  395. # line 79 "p.y"
  396. {flerror = 1;yyval.trees=tnoop();} break;
  397. case 19:
  398. # line 80 "p.y"
  399. {flerror = 1;yyval.trees=tnoop();} break;
  400. case 20:
  401. # line 83 "p.y"
  402. {
  403.                     level++;
  404.                 } break;
  405. case 21:
  406. # line 87 "p.y"
  407. {
  408.                     sp1=lookup(yypvt[-2].str);
  409.                     if (sp1==NULL) {
  410.                sprintf(str,"note: %s has been auto declared",yypvt[-2].str);
  411.                 sp1=install(yypvt[-2].str,S_GLOBAL,T_FLOAT);
  412.                              yyerror (str);     
  413.                     }
  414.                     yyval.trees = tstore(tname(sp1),yypvt[-0].trees); 
  415.                 } break;
  416. case 22:
  417. # line 96 "p.y"
  418. {yyval.trees = tcall (yypvt[-1].trees,yypvt[-3].str);} break;
  419. case 23:
  420. # line 100 "p.y"
  421. { idlist[idcount++]=yypvt[-0].str;} break;
  422. case 24:
  423. # line 101 "p.y"
  424. { idlist[idcount++]=yypvt[-0].str;} break;
  425. case 25:
  426. # line 104 "p.y"
  427. { yyval.str = strsave(yytext);} break;
  428. case 26:
  429. # line 107 "p.y"
  430. {yyval.trees = targ(tnoargs(),yypvt[-0].trees);} break;
  431. case 27:
  432. # line 108 "p.y"
  433. { yyval.trees = targ(yypvt[-2].trees,yypvt[-0].trees); } break;
  434. case 28:
  435. # line 112 "p.y"
  436. { 
  437.             yyval.trees = targ(tnoargs(),yypvt[-0].trees);
  438.             } break;
  439. case 29:
  440. # line 115 "p.y"
  441. {
  442.             yyval.trees = targ(yypvt[-2].trees,yypvt[-0].trees);
  443.             } break;
  444. case 30:
  445. # line 118 "p.y"
  446. {yyval.trees = tnoargs();} break;
  447. case 31:
  448. # line 120 "p.y"
  449. {
  450.             c1 = yytext + 1;
  451.             c1[strlen(c1)-1]= '\0';
  452. /* Here we do some weird conversion from char* to int to double.
  453.  * It is a hack that allows to pass strings to cmix functions, 
  454.  * in a way, that only the function needs to know about it.
  455.  * It very likely to be machine dependent, so you might have to hack it
  456.  * if it doesn't work on your system.  If you do, send me mail. ***lars.
  457.  * (It might help to look at the assembler output produced by cc)
  458.  */
  459.             i1 =  strsave(c1);
  460.             d1 = (double) i1;
  461.             yyval.trees = tconstf(d1);
  462.             } break;
  463. case 32:
  464. # line 136 "p.y"
  465. { yyval.trees = yypvt[-0].trees;} break;
  466. case 33:
  467. # line 137 "p.y"
  468. { yyval.trees = tnot(yypvt[-0].trees);    } break;
  469. case 34:
  470. # line 138 "p.y"
  471. { yyval.trees = tcand(yypvt[-2].trees,yypvt[-0].trees);   } break;
  472. case 35:
  473. # line 139 "p.y"
  474. { yyval.trees = tcor(yypvt[-2].trees,yypvt[-0].trees);  } break;
  475. case 36:
  476. # line 141 "p.y"
  477. { yyval.trees = trel(EQ,yypvt[-2].trees,yypvt[-0].trees); } break;
  478. case 37:
  479. # line 142 "p.y"
  480. { yyval.trees = trel(LT,yypvt[-2].trees,yypvt[-0].trees); } break;
  481. case 38:
  482. # line 143 "p.y"
  483. { yyval.trees = trel(GT,yypvt[-2].trees,yypvt[-0].trees);} break;
  484. case 39:
  485. # line 144 "p.y"
  486. { yyval.trees = trel(NEQ,yypvt[-2].trees,yypvt[-0].trees);} break;
  487. case 40:
  488. # line 145 "p.y"
  489. { yyval.trees = trel(LEQ,yypvt[-2].trees,yypvt[-0].trees); } break;
  490. case 41:
  491. # line 146 "p.y"
  492. { yyval.trees = trel(GEQ,yypvt[-2].trees,yypvt[-0].trees); } break;
  493. case 42:
  494. # line 147 "p.y"
  495. {
  496.             yyval.trees = trel (EQ,tconstf(1.0),tconstf(1.0));
  497.             } break;
  498. case 43:
  499. # line 150 "p.y"
  500. {
  501.             yyval.trees = trel (NEQ,tconstf(1.0),tconstf(1.0));
  502.             } break;
  503. case 44:
  504. # line 155 "p.y"
  505. { yyval.trees = top(POW,yypvt[-2].trees,yypvt[-0].trees); } break;
  506. case 45:
  507. # line 156 "p.y"
  508. { yyval.trees = yypvt[-0].trees;} break;
  509. case 46:
  510. # line 157 "p.y"
  511. { yyval.trees = top(MUL,yypvt[-2].trees,yypvt[-0].trees); } break;
  512. case 47:
  513. # line 158 "p.y"
  514. { yyval.trees = top(DIV,yypvt[-2].trees,yypvt[-0].trees); } break;
  515. case 48:
  516. # line 159 "p.y"
  517. { yyval.trees = top(PLUS,yypvt[-2].trees,yypvt[-0].trees); } break;
  518. case 49:
  519. # line 160 "p.y"
  520. { yyval.trees = top(MINUS,yypvt[-2].trees,yypvt[-0].trees); } break;
  521. case 50:
  522. # line 161 "p.y"
  523. { yyval.trees = yypvt[-1].trees;} break;
  524. case 51:
  525. # line 162 "p.y"
  526. {
  527.             f1 = atof(yytext);
  528.             yyval.trees = tconstf(f1);
  529.                } break;
  530. case 52:
  531. # line 166 "p.y"
  532. {
  533.             f1 = atof(yytext);
  534.             yyval.trees = tconstf(-f1);
  535.                } break;
  536. case 53:
  537. # line 170 "p.y"
  538. {
  539.         
  540.         sp1=lookup(yypvt[-0].str);
  541.         if (sp1==NULL) {
  542.           sprintf(str,"error: %s is not declared",yypvt[-0].str);
  543.             yyerror (str);     
  544.           yyval.trees = tconstf(0.0);
  545.         }else  yyval.trees = tname(sp1);
  546.     } break;
  547. # line 148 "/usr/lib/yaccpar"
  548.  
  549.         }
  550.         goto yystack;  /* stack new state and value */
  551.  
  552.     }
  553.